//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS OpenSearchServerless service.
///
/// Use the Amazon OpenSearch Serverless API to create, configure, and manage OpenSearch Serverless collections and security policies. OpenSearch Serverless is an on-demand, pre-provisioned serverless configuration for Amazon OpenSearch Service. OpenSearch Serverless removes the operational complexities of provisioning, configuring, and tuning your OpenSearch clusters. It enables you to easily search and analyze petabytes of data without having to worry about the underlying infrastructure and data management. To learn more about OpenSearch Serverless, see What is Amazon OpenSearch Serverless?
public struct OpenSearchServerless: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the OpenSearchServerless client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "OpenSearchServerless",
            serviceName: "OpenSearchServerless",
            serviceIdentifier: "aoss",
            serviceProtocol: .json(version: "1.0"),
            apiVersion: "2021-11-01",
            endpoint: endpoint,
            errorType: OpenSearchServerlessErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Returns attributes for one or more collections, including the collection endpoint, the OpenSearch Dashboards endpoint, and FIPS-compliant endpoints. For more information, see Creating and managing Amazon OpenSearch Serverless collections.
    @Sendable
    @inlinable
    public func batchGetCollection(_ input: BatchGetCollectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetCollectionResponse {
        try await self.client.execute(
            operation: "BatchGetCollection", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns attributes for one or more collections, including the collection endpoint, the OpenSearch Dashboards endpoint, and FIPS-compliant endpoints. For more information, see Creating and managing Amazon OpenSearch Serverless collections.
    ///
    /// Parameters:
    ///   - ids: A list of collection IDs. You can't provide names and IDs in the same request. The ID is part of the collection endpoint. You can also retrieve it using the ListCollections API.
    ///   - names: A list of collection names. You can't provide names and IDs in the same request.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetCollection(
        ids: [String]? = nil,
        names: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetCollectionResponse {
        let input = BatchGetCollectionRequest(
            ids: ids, 
            names: names
        )
        return try await self.batchGetCollection(input, logger: logger)
    }

    /// Returns a list of successful and failed retrievals for the OpenSearch Serverless indexes. For more information, see Viewing data lifecycle policies.
    @Sendable
    @inlinable
    public func batchGetEffectiveLifecyclePolicy(_ input: BatchGetEffectiveLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetEffectiveLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "BatchGetEffectiveLifecyclePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of successful and failed retrievals for the OpenSearch Serverless indexes. For more information, see Viewing data lifecycle policies.
    ///
    /// Parameters:
    ///   - resourceIdentifiers: The unique identifiers of policy types and resource names.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetEffectiveLifecyclePolicy(
        resourceIdentifiers: [LifecyclePolicyResourceIdentifier],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetEffectiveLifecyclePolicyResponse {
        let input = BatchGetEffectiveLifecyclePolicyRequest(
            resourceIdentifiers: resourceIdentifiers
        )
        return try await self.batchGetEffectiveLifecyclePolicy(input, logger: logger)
    }

    /// Returns one or more configured OpenSearch Serverless lifecycle policies. For more information, see Viewing data lifecycle policies.
    @Sendable
    @inlinable
    public func batchGetLifecyclePolicy(_ input: BatchGetLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "BatchGetLifecyclePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns one or more configured OpenSearch Serverless lifecycle policies. For more information, see Viewing data lifecycle policies.
    ///
    /// Parameters:
    ///   - identifiers: The unique identifiers of policy types and policy names.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetLifecyclePolicy(
        identifiers: [LifecyclePolicyIdentifier],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetLifecyclePolicyResponse {
        let input = BatchGetLifecyclePolicyRequest(
            identifiers: identifiers
        )
        return try await self.batchGetLifecyclePolicy(input, logger: logger)
    }

    /// Returns attributes for one or more VPC endpoints associated with the current account. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    @Sendable
    @inlinable
    public func batchGetVpcEndpoint(_ input: BatchGetVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetVpcEndpointResponse {
        try await self.client.execute(
            operation: "BatchGetVpcEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns attributes for one or more VPC endpoints associated with the current account. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    ///
    /// Parameters:
    ///   - ids: A list of VPC endpoint identifiers.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetVpcEndpoint(
        ids: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetVpcEndpointResponse {
        let input = BatchGetVpcEndpointRequest(
            ids: ids
        )
        return try await self.batchGetVpcEndpoint(input, logger: logger)
    }

    /// Creates a data access policy for OpenSearch Serverless. Access policies limit access to collections and the resources within them, and allow a user to access that data irrespective of the access mechanism or network source. For more information, see Data access control for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func createAccessPolicy(_ input: CreateAccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAccessPolicyResponse {
        try await self.client.execute(
            operation: "CreateAccessPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a data access policy for OpenSearch Serverless. Access policies limit access to collections and the resources within them, and allow a user to access that data irrespective of the access mechanism or network source. For more information, see Data access control for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the policy. Typically used to store information about the permissions defined in the policy.
    ///   - name: The name of the policy.
    ///   - policy: The JSON policy document to use as the content for the policy.
    ///   - type: The type of policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAccessPolicy(
        clientToken: String? = CreateAccessPolicyRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        policy: String,
        type: AccessPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAccessPolicyResponse {
        let input = CreateAccessPolicyRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            policy: policy, 
            type: type
        )
        return try await self.createAccessPolicy(input, logger: logger)
    }

    /// Creates a new OpenSearch Serverless collection. For more information, see Creating and managing Amazon OpenSearch Serverless collections.
    @Sendable
    @inlinable
    public func createCollection(_ input: CreateCollectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCollectionResponse {
        try await self.client.execute(
            operation: "CreateCollection", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a new OpenSearch Serverless collection. For more information, see Creating and managing Amazon OpenSearch Serverless collections.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: Description of the collection.
    ///   - name: Name of the collection.
    ///   - standbyReplicas: Indicates whether standby replicas should be used for a collection.
    ///   - tags: An arbitrary set of tags (key–value pairs) to associate with the OpenSearch Serverless collection.
    ///   - type: The type of collection.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCollection(
        clientToken: String? = CreateCollectionRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        standbyReplicas: StandbyReplicas? = nil,
        tags: [Tag]? = nil,
        type: CollectionType? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCollectionResponse {
        let input = CreateCollectionRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            standbyReplicas: standbyReplicas, 
            tags: tags, 
            type: type
        )
        return try await self.createCollection(input, logger: logger)
    }

    /// Creates an index within an OpenSearch Serverless collection. Unlike other OpenSearch indexes, indexes created by this API are automatically configured to conduct automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment in the OpenSearch User Guide.
    @Sendable
    @inlinable
    public func createIndex(_ input: CreateIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateIndexResponse {
        try await self.client.execute(
            operation: "CreateIndex", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an index within an OpenSearch Serverless collection. Unlike other OpenSearch indexes, indexes created by this API are automatically configured to conduct automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment in the OpenSearch User Guide.
    ///
    /// Parameters:
    ///   - id: The unique identifier of the collection in which to create the index.
    ///   - indexName: The name of the index to create. Index names must be lowercase and can't begin with underscores (_) or hyphens (-).
    ///   - indexSchema: The JSON schema definition for the index, including field mappings and settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func createIndex(
        id: String,
        indexName: String,
        indexSchema: AWSDocument? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateIndexResponse {
        let input = CreateIndexRequest(
            id: id, 
            indexName: indexName, 
            indexSchema: indexSchema
        )
        return try await self.createIndex(input, logger: logger)
    }

    /// Creates a lifecyle policy to be applied to OpenSearch Serverless indexes. Lifecycle policies define the number of days or hours to retain the data on an OpenSearch Serverless index. For more information, see Creating data lifecycle policies.
    @Sendable
    @inlinable
    public func createLifecyclePolicy(_ input: CreateLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "CreateLifecyclePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a lifecyle policy to be applied to OpenSearch Serverless indexes. Lifecycle policies define the number of days or hours to retain the data on an OpenSearch Serverless index. For more information, see Creating data lifecycle policies.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the lifecycle policy.
    ///   - name: The name of the lifecycle policy.
    ///   - policy: The JSON policy document to use as the content for the lifecycle policy.
    ///   - type: The type of lifecycle policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func createLifecyclePolicy(
        clientToken: String? = CreateLifecyclePolicyRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        policy: String,
        type: LifecyclePolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateLifecyclePolicyResponse {
        let input = CreateLifecyclePolicyRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            policy: policy, 
            type: type
        )
        return try await self.createLifecyclePolicy(input, logger: logger)
    }

    /// Specifies a security configuration for OpenSearch Serverless. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func createSecurityConfig(_ input: CreateSecurityConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSecurityConfigResponse {
        try await self.client.execute(
            operation: "CreateSecurityConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Specifies a security configuration for OpenSearch Serverless. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the security configuration.
    ///   - iamFederationOptions: Describes IAM federation options in the form of a key-value map. This field is required if you specify iamFederation for the type parameter.
    ///   - iamIdentityCenterOptions: Describes IAM Identity Center options in the form of a key-value map. This field is required if you specify iamidentitycenter for the type parameter.
    ///   - name: The name of the security configuration.
    ///   - samlOptions: Describes SAML options in in the form of a key-value map. This field is required if you specify SAML for the type parameter.
    ///   - type: The type of security configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSecurityConfig(
        clientToken: String? = CreateSecurityConfigRequest.idempotencyToken(),
        description: String? = nil,
        iamFederationOptions: IamFederationConfigOptions? = nil,
        iamIdentityCenterOptions: CreateIamIdentityCenterConfigOptions? = nil,
        name: String,
        samlOptions: SamlConfigOptions? = nil,
        type: SecurityConfigType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSecurityConfigResponse {
        let input = CreateSecurityConfigRequest(
            clientToken: clientToken, 
            description: description, 
            iamFederationOptions: iamFederationOptions, 
            iamIdentityCenterOptions: iamIdentityCenterOptions, 
            name: name, 
            samlOptions: samlOptions, 
            type: type
        )
        return try await self.createSecurityConfig(input, logger: logger)
    }

    /// Creates a security policy to be used by one or more OpenSearch Serverless collections. Security policies provide access to a collection and its OpenSearch Dashboards endpoint from public networks or specific VPC endpoints. They also allow you to secure a collection with a KMS encryption key. For more information, see Network access for Amazon OpenSearch Serverless and Encryption at rest for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func createSecurityPolicy(_ input: CreateSecurityPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSecurityPolicyResponse {
        try await self.client.execute(
            operation: "CreateSecurityPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a security policy to be used by one or more OpenSearch Serverless collections. Security policies provide access to a collection and its OpenSearch Dashboards endpoint from public networks or specific VPC endpoints. They also allow you to secure a collection with a KMS encryption key. For more information, see Network access for Amazon OpenSearch Serverless and Encryption at rest for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the policy. Typically used to store information about the permissions defined in the policy.
    ///   - name: The name of the policy.
    ///   - policy: The JSON policy document to use as the content for the new policy.
    ///   - type: The type of security policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSecurityPolicy(
        clientToken: String? = CreateSecurityPolicyRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        policy: String,
        type: SecurityPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSecurityPolicyResponse {
        let input = CreateSecurityPolicyRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            policy: policy, 
            type: type
        )
        return try await self.createSecurityPolicy(input, logger: logger)
    }

    /// Creates an OpenSearch Serverless-managed interface VPC endpoint. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    @Sendable
    @inlinable
    public func createVpcEndpoint(_ input: CreateVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateVpcEndpointResponse {
        try await self.client.execute(
            operation: "CreateVpcEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates an OpenSearch Serverless-managed interface VPC endpoint. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - name: The name of the interface endpoint.
    ///   - securityGroupIds: The unique identifiers of the security groups that define the ports, protocols, and sources for inbound traffic that you are authorizing into your endpoint.
    ///   - subnetIds: The ID of one or more subnets from which you'll access OpenSearch Serverless.
    ///   - vpcId: The ID of the VPC from which you'll access OpenSearch Serverless.
    ///   - logger: Logger use during operation
    @inlinable
    public func createVpcEndpoint(
        clientToken: String? = CreateVpcEndpointRequest.idempotencyToken(),
        name: String,
        securityGroupIds: [String]? = nil,
        subnetIds: [String],
        vpcId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateVpcEndpointResponse {
        let input = CreateVpcEndpointRequest(
            clientToken: clientToken, 
            name: name, 
            securityGroupIds: securityGroupIds, 
            subnetIds: subnetIds, 
            vpcId: vpcId
        )
        return try await self.createVpcEndpoint(input, logger: logger)
    }

    /// Deletes an OpenSearch Serverless access policy. For more information, see Data access control for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func deleteAccessPolicy(_ input: DeleteAccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAccessPolicyResponse {
        try await self.client.execute(
            operation: "DeleteAccessPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an OpenSearch Serverless access policy. For more information, see Data access control for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - name: The name of the policy to delete.
    ///   - type: The type of policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAccessPolicy(
        clientToken: String? = DeleteAccessPolicyRequest.idempotencyToken(),
        name: String,
        type: AccessPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAccessPolicyResponse {
        let input = DeleteAccessPolicyRequest(
            clientToken: clientToken, 
            name: name, 
            type: type
        )
        return try await self.deleteAccessPolicy(input, logger: logger)
    }

    /// Deletes an OpenSearch Serverless collection. For more information, see Creating and managing Amazon OpenSearch Serverless collections.
    @Sendable
    @inlinable
    public func deleteCollection(_ input: DeleteCollectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCollectionResponse {
        try await self.client.execute(
            operation: "DeleteCollection", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an OpenSearch Serverless collection. For more information, see Creating and managing Amazon OpenSearch Serverless collections.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - id: The unique identifier of the collection. For example, 1iu5usc406kd. The ID is part of the collection endpoint. You can also retrieve it using the ListCollections API.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCollection(
        clientToken: String? = DeleteCollectionRequest.idempotencyToken(),
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCollectionResponse {
        let input = DeleteCollectionRequest(
            clientToken: clientToken, 
            id: id
        )
        return try await self.deleteCollection(input, logger: logger)
    }

    /// Deletes an index from an OpenSearch Serverless collection. Be aware that the index might be configured to conduct automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment.
    @Sendable
    @inlinable
    public func deleteIndex(_ input: DeleteIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteIndexResponse {
        try await self.client.execute(
            operation: "DeleteIndex", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an index from an OpenSearch Serverless collection. Be aware that the index might be configured to conduct automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment.
    ///
    /// Parameters:
    ///   - id: The unique identifier of the collection containing the index to delete.
    ///   - indexName: The name of the index to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteIndex(
        id: String,
        indexName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteIndexResponse {
        let input = DeleteIndexRequest(
            id: id, 
            indexName: indexName
        )
        return try await self.deleteIndex(input, logger: logger)
    }

    /// Deletes an OpenSearch Serverless lifecycle policy. For more information, see Deleting data lifecycle policies.
    @Sendable
    @inlinable
    public func deleteLifecyclePolicy(_ input: DeleteLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "DeleteLifecyclePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an OpenSearch Serverless lifecycle policy. For more information, see Deleting data lifecycle policies.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - name: The name of the policy to delete.
    ///   - type: The type of lifecycle policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteLifecyclePolicy(
        clientToken: String? = DeleteLifecyclePolicyRequest.idempotencyToken(),
        name: String,
        type: LifecyclePolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteLifecyclePolicyResponse {
        let input = DeleteLifecyclePolicyRequest(
            clientToken: clientToken, 
            name: name, 
            type: type
        )
        return try await self.deleteLifecyclePolicy(input, logger: logger)
    }

    /// Deletes a security configuration for OpenSearch Serverless. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func deleteSecurityConfig(_ input: DeleteSecurityConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSecurityConfigResponse {
        try await self.client.execute(
            operation: "DeleteSecurityConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a security configuration for OpenSearch Serverless. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - id: The security configuration identifier. For SAML the ID will be saml/&lt;accountId&gt;/&lt;idpProviderName&gt;. For example, saml/123456789123/OKTADev.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSecurityConfig(
        clientToken: String? = DeleteSecurityConfigRequest.idempotencyToken(),
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSecurityConfigResponse {
        let input = DeleteSecurityConfigRequest(
            clientToken: clientToken, 
            id: id
        )
        return try await self.deleteSecurityConfig(input, logger: logger)
    }

    /// Deletes an OpenSearch Serverless security policy.
    @Sendable
    @inlinable
    public func deleteSecurityPolicy(_ input: DeleteSecurityPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSecurityPolicyResponse {
        try await self.client.execute(
            operation: "DeleteSecurityPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an OpenSearch Serverless security policy.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - name: The name of the policy to delete.
    ///   - type: The type of policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteSecurityPolicy(
        clientToken: String? = DeleteSecurityPolicyRequest.idempotencyToken(),
        name: String,
        type: SecurityPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSecurityPolicyResponse {
        let input = DeleteSecurityPolicyRequest(
            clientToken: clientToken, 
            name: name, 
            type: type
        )
        return try await self.deleteSecurityPolicy(input, logger: logger)
    }

    /// Deletes an OpenSearch Serverless-managed interface endpoint. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    @Sendable
    @inlinable
    public func deleteVpcEndpoint(_ input: DeleteVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteVpcEndpointResponse {
        try await self.client.execute(
            operation: "DeleteVpcEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an OpenSearch Serverless-managed interface endpoint. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - id: The VPC endpoint identifier.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteVpcEndpoint(
        clientToken: String? = DeleteVpcEndpointRequest.idempotencyToken(),
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteVpcEndpointResponse {
        let input = DeleteVpcEndpointRequest(
            clientToken: clientToken, 
            id: id
        )
        return try await self.deleteVpcEndpoint(input, logger: logger)
    }

    /// Returns an OpenSearch Serverless access policy. For more information, see Data access control for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func getAccessPolicy(_ input: GetAccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccessPolicyResponse {
        try await self.client.execute(
            operation: "GetAccessPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns an OpenSearch Serverless access policy. For more information, see Data access control for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - name: The name of the access policy.
    ///   - type: Tye type of policy. Currently, the only supported value is data.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccessPolicy(
        name: String,
        type: AccessPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccessPolicyResponse {
        let input = GetAccessPolicyRequest(
            name: name, 
            type: type
        )
        return try await self.getAccessPolicy(input, logger: logger)
    }

    /// Returns account-level settings related to OpenSearch Serverless.
    @Sendable
    @inlinable
    public func getAccountSettings(_ input: GetAccountSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAccountSettingsResponse {
        try await self.client.execute(
            operation: "GetAccountSettings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns account-level settings related to OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAccountSettings(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAccountSettingsResponse {
        let input = GetAccountSettingsRequest(
        )
        return try await self.getAccountSettings(input, logger: logger)
    }

    /// Retrieves information about an index in an OpenSearch Serverless collection, including its schema definition. The index might be configured to conduct automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment.
    @Sendable
    @inlinable
    public func getIndex(_ input: GetIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetIndexResponse {
        try await self.client.execute(
            operation: "GetIndex", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an index in an OpenSearch Serverless collection, including its schema definition. The index might be configured to conduct automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment.
    ///
    /// Parameters:
    ///   - id: The unique identifier of the collection containing the index.
    ///   - indexName: The name of the index to retrieve information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func getIndex(
        id: String,
        indexName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetIndexResponse {
        let input = GetIndexRequest(
            id: id, 
            indexName: indexName
        )
        return try await self.getIndex(input, logger: logger)
    }

    /// Returns statistical information about your OpenSearch Serverless access policies, security configurations, and security policies.
    @Sendable
    @inlinable
    public func getPoliciesStats(_ input: GetPoliciesStatsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetPoliciesStatsResponse {
        try await self.client.execute(
            operation: "GetPoliciesStats", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns statistical information about your OpenSearch Serverless access policies, security configurations, and security policies.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getPoliciesStats(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetPoliciesStatsResponse {
        let input = GetPoliciesStatsRequest(
        )
        return try await self.getPoliciesStats(input, logger: logger)
    }

    /// Returns information about an OpenSearch Serverless security configuration. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func getSecurityConfig(_ input: GetSecurityConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSecurityConfigResponse {
        try await self.client.execute(
            operation: "GetSecurityConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about an OpenSearch Serverless security configuration. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - id: The unique identifier of the security configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSecurityConfig(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSecurityConfigResponse {
        let input = GetSecurityConfigRequest(
            id: id
        )
        return try await self.getSecurityConfig(input, logger: logger)
    }

    /// Returns information about a configured OpenSearch Serverless security policy. For more information, see Network access for Amazon OpenSearch Serverless and Encryption at rest for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func getSecurityPolicy(_ input: GetSecurityPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSecurityPolicyResponse {
        try await self.client.execute(
            operation: "GetSecurityPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a configured OpenSearch Serverless security policy. For more information, see Network access for Amazon OpenSearch Serverless and Encryption at rest for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - name: The name of the security policy.
    ///   - type: The type of security policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSecurityPolicy(
        name: String,
        type: SecurityPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSecurityPolicyResponse {
        let input = GetSecurityPolicyRequest(
            name: name, 
            type: type
        )
        return try await self.getSecurityPolicy(input, logger: logger)
    }

    /// Returns information about a list of OpenSearch Serverless access policies.
    @Sendable
    @inlinable
    public func listAccessPolicies(_ input: ListAccessPoliciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAccessPoliciesResponse {
        try await self.client.execute(
            operation: "ListAccessPolicies", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about a list of OpenSearch Serverless access policies.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - nextToken: If your initial ListAccessPolicies operation returns a nextToken, you can include the returned nextToken in subsequent ListAccessPolicies operations, which returns results in the next page.
    ///   - resource: Resource filters (can be collections or indexes) that policies can apply to.
    ///   - type: The type of access policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAccessPolicies(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resource: [String]? = nil,
        type: AccessPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAccessPoliciesResponse {
        let input = ListAccessPoliciesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resource: resource, 
            type: type
        )
        return try await self.listAccessPolicies(input, logger: logger)
    }

    /// Lists all OpenSearch Serverless collections. For more information, see Creating and managing Amazon OpenSearch Serverless collections.  Make sure to include an empty request body {} if you don't include any collection filters in the request.
    @Sendable
    @inlinable
    public func listCollections(_ input: ListCollectionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCollectionsResponse {
        try await self.client.execute(
            operation: "ListCollections", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all OpenSearch Serverless collections. For more information, see Creating and managing Amazon OpenSearch Serverless collections.  Make sure to include an empty request body {} if you don't include any collection filters in the request.
    ///
    /// Parameters:
    ///   - collectionFilters:  A list of filter names and values that you can use for requests.
    ///   - maxResults: The maximum number of results to return. Default is 20. You can use nextToken to get the next page of results.
    ///   - nextToken: If your initial ListCollections operation returns a nextToken, you can include the returned nextToken in subsequent ListCollections operations, which returns results in the next page.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCollections(
        collectionFilters: CollectionFilters? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCollectionsResponse {
        let input = ListCollectionsRequest(
            collectionFilters: collectionFilters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCollections(input, logger: logger)
    }

    /// Returns a list of OpenSearch Serverless lifecycle policies. For more information, see Viewing data lifecycle policies.
    @Sendable
    @inlinable
    public func listLifecyclePolicies(_ input: ListLifecyclePoliciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListLifecyclePoliciesResponse {
        try await self.client.execute(
            operation: "ListLifecyclePolicies", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of OpenSearch Serverless lifecycle policies. For more information, see Viewing data lifecycle policies.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use use nextToken to get the next page of results. The default is 10.
    ///   - nextToken: If your initial ListLifecyclePolicies operation returns a nextToken, you can include the returned nextToken in subsequent ListLifecyclePolicies operations, which returns results in the next page.
    ///   - resources: Resource filters that policies can apply to. Currently, the only supported resource type is index.
    ///   - type: The type of lifecycle policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func listLifecyclePolicies(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resources: [String]? = nil,
        type: LifecyclePolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListLifecyclePoliciesResponse {
        let input = ListLifecyclePoliciesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resources: resources, 
            type: type
        )
        return try await self.listLifecyclePolicies(input, logger: logger)
    }

    /// Returns information about configured OpenSearch Serverless security configurations. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func listSecurityConfigs(_ input: ListSecurityConfigsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSecurityConfigsResponse {
        try await self.client.execute(
            operation: "ListSecurityConfigs", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about configured OpenSearch Serverless security configurations. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - nextToken: If your initial ListSecurityConfigs operation returns a nextToken, you can include the returned nextToken in subsequent ListSecurityConfigs operations, which returns results in the next page.
    ///   - type: The type of security configuration.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSecurityConfigs(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        type: SecurityConfigType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSecurityConfigsResponse {
        let input = ListSecurityConfigsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            type: type
        )
        return try await self.listSecurityConfigs(input, logger: logger)
    }

    /// Returns information about configured OpenSearch Serverless security policies.
    @Sendable
    @inlinable
    public func listSecurityPolicies(_ input: ListSecurityPoliciesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSecurityPoliciesResponse {
        try await self.client.execute(
            operation: "ListSecurityPolicies", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns information about configured OpenSearch Serverless security policies.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - nextToken: If your initial ListSecurityPolicies operation returns a nextToken, you can include the returned nextToken in subsequent ListSecurityPolicies operations, which returns results in the next page.
    ///   - resource: Resource filters (can be collection or indexes) that policies can apply to.
    ///   - type: The type of policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSecurityPolicies(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resource: [String]? = nil,
        type: SecurityPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSecurityPoliciesResponse {
        let input = ListSecurityPoliciesRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resource: resource, 
            type: type
        )
        return try await self.listSecurityPolicies(input, logger: logger)
    }

    /// Returns the tags for an OpenSearch Serverless resource. For more information, see Tagging Amazon OpenSearch Serverless collections.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the tags for an OpenSearch Serverless resource. For more information, see Tagging Amazon OpenSearch Serverless collections.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource. The resource must be active (not in the DELETING state), and must be owned by the account ID included in the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Returns the OpenSearch Serverless-managed interface VPC endpoints associated with the current account. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    @Sendable
    @inlinable
    public func listVpcEndpoints(_ input: ListVpcEndpointsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListVpcEndpointsResponse {
        try await self.client.execute(
            operation: "ListVpcEndpoints", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns the OpenSearch Serverless-managed interface VPC endpoints associated with the current account. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    ///
    /// Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - nextToken: If your initial ListVpcEndpoints operation returns a nextToken, you can include the returned nextToken in subsequent ListVpcEndpoints operations, which returns results in the next page.
    ///   - vpcEndpointFilters: Filter the results according to the current status of the VPC endpoint. Possible statuses are CREATING, DELETING, UPDATING, ACTIVE, and FAILED.
    ///   - logger: Logger use during operation
    @inlinable
    public func listVpcEndpoints(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        vpcEndpointFilters: VpcEndpointFilters? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListVpcEndpointsResponse {
        let input = ListVpcEndpointsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            vpcEndpointFilters: vpcEndpointFilters
        )
        return try await self.listVpcEndpoints(input, logger: logger)
    }

    /// Associates tags with an OpenSearch Serverless resource. For more information, see Tagging Amazon OpenSearch Serverless collections.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates tags with an OpenSearch Serverless resource. For more information, see Tagging Amazon OpenSearch Serverless collections.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource. The resource must be active (not in the DELETING state), and must be owned by the account ID included in the request.
    ///   - tags: A list of tags (key-value pairs) to add to the resource. All tag keys in the request must be unique.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a tag or set of tags from an OpenSearch Serverless resource. For more information, see Tagging Amazon OpenSearch Serverless collections.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag or set of tags from an OpenSearch Serverless resource. For more information, see Tagging Amazon OpenSearch Serverless collections.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource to remove tags from. The resource must be active (not in the DELETING state), and must be owned by the account ID included in the request.
    ///   - tagKeys: The tag or set of tags to remove from the resource. All tag keys in the request must be unique.
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates an OpenSearch Serverless access policy. For more information, see Data access control for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func updateAccessPolicy(_ input: UpdateAccessPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAccessPolicyResponse {
        try await self.client.execute(
            operation: "UpdateAccessPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an OpenSearch Serverless access policy. For more information, see Data access control for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the policy. Typically used to store information about the permissions defined in the policy.
    ///   - name: The name of the policy.
    ///   - policy: The JSON policy document to use as the content for the policy.
    ///   - policyVersion: The version of the policy being updated.
    ///   - type: The type of policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccessPolicy(
        clientToken: String? = UpdateAccessPolicyRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        policy: String? = nil,
        policyVersion: String,
        type: AccessPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAccessPolicyResponse {
        let input = UpdateAccessPolicyRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            policy: policy, 
            policyVersion: policyVersion, 
            type: type
        )
        return try await self.updateAccessPolicy(input, logger: logger)
    }

    /// Update the OpenSearch Serverless settings for the current Amazon Web Services account. For more information, see Managing capacity limits for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func updateAccountSettings(_ input: UpdateAccountSettingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAccountSettingsResponse {
        try await self.client.execute(
            operation: "UpdateAccountSettings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Update the OpenSearch Serverless settings for the current Amazon Web Services account. For more information, see Managing capacity limits for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - capacityLimits: 
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAccountSettings(
        capacityLimits: CapacityLimits? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAccountSettingsResponse {
        let input = UpdateAccountSettingsRequest(
            capacityLimits: capacityLimits
        )
        return try await self.updateAccountSettings(input, logger: logger)
    }

    /// Updates an OpenSearch Serverless collection.
    @Sendable
    @inlinable
    public func updateCollection(_ input: UpdateCollectionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateCollectionResponse {
        try await self.client.execute(
            operation: "UpdateCollection", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an OpenSearch Serverless collection.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the collection.
    ///   - id: The unique identifier of the collection.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateCollection(
        clientToken: String? = UpdateCollectionRequest.idempotencyToken(),
        description: String? = nil,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateCollectionResponse {
        let input = UpdateCollectionRequest(
            clientToken: clientToken, 
            description: description, 
            id: id
        )
        return try await self.updateCollection(input, logger: logger)
    }

    /// Updates an existing index in an OpenSearch Serverless collection. This operation allows you to modify the index schema, including adding new fields or changing field mappings. You can also enable automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment.
    @Sendable
    @inlinable
    public func updateIndex(_ input: UpdateIndexRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateIndexResponse {
        try await self.client.execute(
            operation: "UpdateIndex", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an existing index in an OpenSearch Serverless collection. This operation allows you to modify the index schema, including adding new fields or changing field mappings. You can also enable automatic semantic enrichment ingestion and search. For more information, see About automatic semantic enrichment.
    ///
    /// Parameters:
    ///   - id: The unique identifier of the collection containing the index to update.
    ///   - indexName: The name of the index to update.
    ///   - indexSchema: The updated JSON schema definition for the index, including field mappings and settings.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateIndex(
        id: String,
        indexName: String,
        indexSchema: AWSDocument? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateIndexResponse {
        let input = UpdateIndexRequest(
            id: id, 
            indexName: indexName, 
            indexSchema: indexSchema
        )
        return try await self.updateIndex(input, logger: logger)
    }

    /// Updates an OpenSearch Serverless access policy. For more information, see Updating data lifecycle policies.
    @Sendable
    @inlinable
    public func updateLifecyclePolicy(_ input: UpdateLifecyclePolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateLifecyclePolicyResponse {
        try await self.client.execute(
            operation: "UpdateLifecyclePolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an OpenSearch Serverless access policy. For more information, see Updating data lifecycle policies.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the lifecycle policy.
    ///   - name: The name of the policy.
    ///   - policy: The JSON policy document to use as the content for the lifecycle policy.
    ///   - policyVersion: The version of the policy being updated.
    ///   - type:  The type of lifecycle policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateLifecyclePolicy(
        clientToken: String? = UpdateLifecyclePolicyRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        policy: String? = nil,
        policyVersion: String,
        type: LifecyclePolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateLifecyclePolicyResponse {
        let input = UpdateLifecyclePolicyRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            policy: policy, 
            policyVersion: policyVersion, 
            type: type
        )
        return try await self.updateLifecyclePolicy(input, logger: logger)
    }

    /// Updates a security configuration for OpenSearch Serverless. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func updateSecurityConfig(_ input: UpdateSecurityConfigRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSecurityConfigResponse {
        try await self.client.execute(
            operation: "UpdateSecurityConfig", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates a security configuration for OpenSearch Serverless. For more information, see SAML authentication for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - configVersion: The version of the security configuration to be updated. You can find the most recent version of a security configuration using the GetSecurityPolicy command.
    ///   - description: A description of the security configuration.
    ///   - iamFederationOptions: Describes IAM federation options in the form of a key-value map for updating an existing security configuration. Use this field to modify IAM federation settings for the security configuration.
    ///   - iamIdentityCenterOptionsUpdates: Describes IAM Identity Center options in the form of a key-value map.
    ///   - id: The security configuration identifier. For SAML the ID will be saml/&lt;accountId&gt;/&lt;idpProviderName&gt;. For example, saml/123456789123/OKTADev.
    ///   - samlOptions: SAML options in in the form of a key-value map.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSecurityConfig(
        clientToken: String? = UpdateSecurityConfigRequest.idempotencyToken(),
        configVersion: String,
        description: String? = nil,
        iamFederationOptions: IamFederationConfigOptions? = nil,
        iamIdentityCenterOptionsUpdates: UpdateIamIdentityCenterConfigOptions? = nil,
        id: String,
        samlOptions: SamlConfigOptions? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSecurityConfigResponse {
        let input = UpdateSecurityConfigRequest(
            clientToken: clientToken, 
            configVersion: configVersion, 
            description: description, 
            iamFederationOptions: iamFederationOptions, 
            iamIdentityCenterOptionsUpdates: iamIdentityCenterOptionsUpdates, 
            id: id, 
            samlOptions: samlOptions
        )
        return try await self.updateSecurityConfig(input, logger: logger)
    }

    /// Updates an OpenSearch Serverless security policy. For more information, see Network access for Amazon OpenSearch Serverless and Encryption at rest for Amazon OpenSearch Serverless.
    @Sendable
    @inlinable
    public func updateSecurityPolicy(_ input: UpdateSecurityPolicyRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSecurityPolicyResponse {
        try await self.client.execute(
            operation: "UpdateSecurityPolicy", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an OpenSearch Serverless security policy. For more information, see Network access for Amazon OpenSearch Serverless and Encryption at rest for Amazon OpenSearch Serverless.
    ///
    /// Parameters:
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - description: A description of the policy. Typically used to store information about the permissions defined in the policy.
    ///   - name: The name of the policy.
    ///   - policy: The JSON policy document to use as the content for the new policy.
    ///   - policyVersion: The version of the policy being updated.
    ///   - type: The type of access policy.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSecurityPolicy(
        clientToken: String? = UpdateSecurityPolicyRequest.idempotencyToken(),
        description: String? = nil,
        name: String,
        policy: String? = nil,
        policyVersion: String,
        type: SecurityPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSecurityPolicyResponse {
        let input = UpdateSecurityPolicyRequest(
            clientToken: clientToken, 
            description: description, 
            name: name, 
            policy: policy, 
            policyVersion: policyVersion, 
            type: type
        )
        return try await self.updateSecurityPolicy(input, logger: logger)
    }

    /// Updates an OpenSearch Serverless-managed interface endpoint. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    @Sendable
    @inlinable
    public func updateVpcEndpoint(_ input: UpdateVpcEndpointRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateVpcEndpointResponse {
        try await self.client.execute(
            operation: "UpdateVpcEndpoint", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates an OpenSearch Serverless-managed interface endpoint. For more information, see Access Amazon OpenSearch Serverless using an interface endpoint.
    ///
    /// Parameters:
    ///   - addSecurityGroupIds: The unique identifiers of the security groups to add to the endpoint. Security groups define the ports, protocols, and sources for inbound traffic that you are authorizing into your endpoint.
    ///   - addSubnetIds: The ID of one or more subnets to add to the endpoint.
    ///   - clientToken: Unique, case-sensitive identifier to ensure idempotency of the request.
    ///   - id: The unique identifier of the interface endpoint to update.
    ///   - removeSecurityGroupIds: The unique identifiers of the security groups to remove from the endpoint.
    ///   - removeSubnetIds: The unique identifiers of the subnets to remove from the endpoint.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateVpcEndpoint(
        addSecurityGroupIds: [String]? = nil,
        addSubnetIds: [String]? = nil,
        clientToken: String? = UpdateVpcEndpointRequest.idempotencyToken(),
        id: String,
        removeSecurityGroupIds: [String]? = nil,
        removeSubnetIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateVpcEndpointResponse {
        let input = UpdateVpcEndpointRequest(
            addSecurityGroupIds: addSecurityGroupIds, 
            addSubnetIds: addSubnetIds, 
            clientToken: clientToken, 
            id: id, 
            removeSecurityGroupIds: removeSecurityGroupIds, 
            removeSubnetIds: removeSubnetIds
        )
        return try await self.updateVpcEndpoint(input, logger: logger)
    }
}

extension OpenSearchServerless {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: OpenSearchServerless, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension OpenSearchServerless {
    /// Return PaginatorSequence for operation ``listAccessPolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccessPoliciesPaginator(
        _ input: ListAccessPoliciesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAccessPoliciesRequest, ListAccessPoliciesResponse> {
        return .init(
            input: input,
            command: self.listAccessPolicies,
            inputKey: \ListAccessPoliciesRequest.nextToken,
            outputKey: \ListAccessPoliciesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAccessPolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - resource: Resource filters (can be collections or indexes) that policies can apply to.
    ///   - type: The type of access policy.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAccessPoliciesPaginator(
        maxResults: Int? = nil,
        resource: [String]? = nil,
        type: AccessPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAccessPoliciesRequest, ListAccessPoliciesResponse> {
        let input = ListAccessPoliciesRequest(
            maxResults: maxResults, 
            resource: resource, 
            type: type
        )
        return self.listAccessPoliciesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCollections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollectionsPaginator(
        _ input: ListCollectionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCollectionsRequest, ListCollectionsResponse> {
        return .init(
            input: input,
            command: self.listCollections,
            inputKey: \ListCollectionsRequest.nextToken,
            outputKey: \ListCollectionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCollections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - collectionFilters:  A list of filter names and values that you can use for requests.
    ///   - maxResults: The maximum number of results to return. Default is 20. You can use nextToken to get the next page of results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCollectionsPaginator(
        collectionFilters: CollectionFilters? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCollectionsRequest, ListCollectionsResponse> {
        let input = ListCollectionsRequest(
            collectionFilters: collectionFilters, 
            maxResults: maxResults
        )
        return self.listCollectionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listLifecyclePolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecyclePoliciesPaginator(
        _ input: ListLifecyclePoliciesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListLifecyclePoliciesRequest, ListLifecyclePoliciesResponse> {
        return .init(
            input: input,
            command: self.listLifecyclePolicies,
            inputKey: \ListLifecyclePoliciesRequest.nextToken,
            outputKey: \ListLifecyclePoliciesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listLifecyclePolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use use nextToken to get the next page of results. The default is 10.
    ///   - resources: Resource filters that policies can apply to. Currently, the only supported resource type is index.
    ///   - type: The type of lifecycle policy.
    ///   - logger: Logger used for logging
    @inlinable
    public func listLifecyclePoliciesPaginator(
        maxResults: Int? = nil,
        resources: [String]? = nil,
        type: LifecyclePolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListLifecyclePoliciesRequest, ListLifecyclePoliciesResponse> {
        let input = ListLifecyclePoliciesRequest(
            maxResults: maxResults, 
            resources: resources, 
            type: type
        )
        return self.listLifecyclePoliciesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSecurityConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityConfigsPaginator(
        _ input: ListSecurityConfigsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSecurityConfigsRequest, ListSecurityConfigsResponse> {
        return .init(
            input: input,
            command: self.listSecurityConfigs,
            inputKey: \ListSecurityConfigsRequest.nextToken,
            outputKey: \ListSecurityConfigsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSecurityConfigs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - type: The type of security configuration.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityConfigsPaginator(
        maxResults: Int? = nil,
        type: SecurityConfigType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSecurityConfigsRequest, ListSecurityConfigsResponse> {
        let input = ListSecurityConfigsRequest(
            maxResults: maxResults, 
            type: type
        )
        return self.listSecurityConfigsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSecurityPolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityPoliciesPaginator(
        _ input: ListSecurityPoliciesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSecurityPoliciesRequest, ListSecurityPoliciesResponse> {
        return .init(
            input: input,
            command: self.listSecurityPolicies,
            inputKey: \ListSecurityPoliciesRequest.nextToken,
            outputKey: \ListSecurityPoliciesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSecurityPolicies(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - resource: Resource filters (can be collection or indexes) that policies can apply to.
    ///   - type: The type of policy.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSecurityPoliciesPaginator(
        maxResults: Int? = nil,
        resource: [String]? = nil,
        type: SecurityPolicyType,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSecurityPoliciesRequest, ListSecurityPoliciesResponse> {
        let input = ListSecurityPoliciesRequest(
            maxResults: maxResults, 
            resource: resource, 
            type: type
        )
        return self.listSecurityPoliciesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listVpcEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listVpcEndpointsPaginator(
        _ input: ListVpcEndpointsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListVpcEndpointsRequest, ListVpcEndpointsResponse> {
        return .init(
            input: input,
            command: self.listVpcEndpoints,
            inputKey: \ListVpcEndpointsRequest.nextToken,
            outputKey: \ListVpcEndpointsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listVpcEndpoints(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: An optional parameter that specifies the maximum number of results to return. You can use nextToken to get the next page of results. The default is 20.
    ///   - vpcEndpointFilters: Filter the results according to the current status of the VPC endpoint. Possible statuses are CREATING, DELETING, UPDATING, ACTIVE, and FAILED.
    ///   - logger: Logger used for logging
    @inlinable
    public func listVpcEndpointsPaginator(
        maxResults: Int? = nil,
        vpcEndpointFilters: VpcEndpointFilters? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListVpcEndpointsRequest, ListVpcEndpointsResponse> {
        let input = ListVpcEndpointsRequest(
            maxResults: maxResults, 
            vpcEndpointFilters: vpcEndpointFilters
        )
        return self.listVpcEndpointsPaginator(input, logger: logger)
    }
}

extension OpenSearchServerless.ListAccessPoliciesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> OpenSearchServerless.ListAccessPoliciesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resource: self.resource,
            type: self.type
        )
    }
}

extension OpenSearchServerless.ListCollectionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> OpenSearchServerless.ListCollectionsRequest {
        return .init(
            collectionFilters: self.collectionFilters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension OpenSearchServerless.ListLifecyclePoliciesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> OpenSearchServerless.ListLifecyclePoliciesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resources: self.resources,
            type: self.type
        )
    }
}

extension OpenSearchServerless.ListSecurityConfigsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> OpenSearchServerless.ListSecurityConfigsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            type: self.type
        )
    }
}

extension OpenSearchServerless.ListSecurityPoliciesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> OpenSearchServerless.ListSecurityPoliciesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resource: self.resource,
            type: self.type
        )
    }
}

extension OpenSearchServerless.ListVpcEndpointsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> OpenSearchServerless.ListVpcEndpointsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            vpcEndpointFilters: self.vpcEndpointFilters
        )
    }
}
